/**
 * Created by Administrator on 2016/3/15.
 * 作者：范庆龙
 * 开发日期：2016/03/15
 * 描述：通用框架
 * 版权不可侵犯
 */
//extend是JQ里继承方法 有利用扩展和维护
//匿名函数是局部的  在外面是调用不到的防止冲突
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~(function (FF) { //匿名函数自制型
    function FQL() {
    };
    FQL.prototype = {
        //可以将一个对象的方法和属性拷贝给另外一个对象
        /*可以给一个对象动态的添加方法*/
        extend: function (tar, source) {
            //遍历对象
            for (var i in source) {
                tar[i] = source[i];
            }
            return tar;
        },
        isString: function (val) {
            return typeof val === "string";
        }
    };
    // 实列化
    var FF = new FQL();
    /*数据类型判断*/
    FF.extend(FF, {
        //数据类型检测
        isNumber: function (val) {
            return typeof val === 'number' && isFinite(val)
        },
        isBoolean: function (val) {
            return typeof val === "boolean";
        },
        isString: function (val) {
            return typeof val === "string";
        },
        isUndefined: function (val) {
            return typeof val === "undefined";
        },
        isObj: function (str) {
            if (str === null || typeof str === 'undefined') {
                return false;
            }
            return typeof str === 'object';
        },
        isNull: function (val) {
            return val === null;
        },
        isArray: function (arr) {
            if (arr === null || typeof arr === 'undefined') {
                return false;
            }
            return arr.constructor === Array;
        },
        random: function (begin, end) {
            return Math.floor(Math.random() * (end - begin)) + begin;
        },
    })
    /*字符串操作*/
    FF.extend(FF, {
        //去除左边空格
        ltrim: function (str) {
            return str.replace(/(^\s*)/g, '');
        },
        //去除右边空格
        rtrim: function (str) {
            return str.replace(/(\s*$)/g, '');
        },
        //去除空格
        trim: function (str) {
            return str.replace(/(^\s*)|(\s*$)/g, '');
        },
        //简单的数据绑定formateString
        formateString: function (str, data) {
            return str.replace(/@\((\w+)\)/g, function (match, key) {
                return typeof data[key] === "undefined" ? '' : data[key]
            });
        },
    })
    /*事件模块--工具包*/
    FF.extend(FF, {
        //绑定事件
        on: function (id, type, fn) {
            //获取元素
            var dom = document.getElementById(id);
            /*骨架*/
            if (document.addEventListener) {
                //标准组织的写法
                dom.addEventListener(type, fn, false);
            } else {
                /*如果是ie浏览器*/
                if (document.attachEvent) {
                    dom.attachEvent('on' + type, fn);
                }
            }
        },
        /*解除绑定*/
        un: function (id, type, fn) {
            var dom = document.getElementById(id)
            if (dom.removeEventListener) {
                /*如果是标准组织的语法规范*/
                dom.removeEventListener(type, fn, false);
            } else {
                if (dom.detachEvent) {
                    /*如果是ie*/
                    dom.detachEvent('on' + type, fn);
                }
            }
        },
        /*点击事件*/
        click: function (id, fn) {
            this.on(id, 'click', fn);
        },
        /*练习*/
        //移开事件
        mouseout: function () {
            $.on(id, 'mouseout', fn);
        },
        //悬浮事件
        mouseover: function () {
            $.on(id, 'mouseover', fn);
        },

        //事件基础
        getEvent: function (event) {
            return event ? event : window.event;
        },
        //获取目标
        GetTarget: function (event) {
            var e = $.getEvent(event);
            return e.target || e.srcElement;
        },
        //阻止默认行为
        preventDefault: function (event) {
            var event = FF.getEvent(event);
            if (event.preventDefault) {
                event.preventDefault();
            } else {
                event.returnValue = false;
            }
        },

        //阻止冒泡
        stopPropagation: function (event) {
            var event = FF.getEvent(event);
            if (event.stopPropagation) {
                event.stopPropagation();
            } else {
                event.cancelBubble = true;
            }
        }
    })
    /*选择器模块*/
    FF.extend(FF, {
        /*id选择器*/
        $id: function (id) {
            this.element = document.getElementById(id);
            return this;
        },
        //第一种
        $tag: function (tag, id) {
            //如果不是ID是一个字符串
            var dom;
            if (FF.isString(id)) {
                dom = FF.$id(id);
            } else {
                //如果Id不是一个字符串，是一个dom对象
                dom = id;
            }
            return (FF.isString(id) ? FF.$id(id) : id).getElementsByTagName(tag);
        },
        //第二种
        $tag: function (tag, id) {
            //搜索范围
            var dom = getid(id);
            //再去找这个范围里面搜索需要的元素
            var doms = gettags(dom, tag);
            return doms;

            //先获取范围   隔离法则
            function getid(id) {
                var dom;
                if (FF.isString(id)) {
                    dom = FF.$id(id);
                } else {
                    //如果Id不是一个字符串，是一个dom对象
                    dom = id;
                }
                return dom;
            }

            //再去找这个范围里面搜索需要的元素
            function gettags(context, tag) {
                return context.getElementsByTagName(tag);
            }
        },
        //完美法则  第三  获取一个或者两个
        $tag: function (tag, id) {
            //搜索范围
            var dom = getid(id);
            //再去找这个范围里面搜索需要的元素
            var doms = gettags(dom, tag);
            return doms;

            //先获取范围   隔离法则
            function getid(id) {
                var dom;
                if (id) {
                    //如果传id
                    if (FF.isString(id)) {
                        dom = FF.$id(id);
                    } else {
                        //如果Id不是一个字符串，是一个dom对象
                        dom = id;
                    }
                } else {
                    //如果不传ID
                    dom = document;
                }
                return dom;
            }

            //再去找这个范围里面搜索需要的元素
            function gettags(context, tag) {
                return context.getElementsByTagName(tag);
            }
        },
        //完美法则
        $class3: function (className) {
            //先获取  所有元素
            var doms = document.getElementsByTagName('*');
            //        然后在所有元素中找到className的元素
            var arr = [] //设置数组接收带className的元素
            for (var i = 0; i < doms.length; i++) {
                if (doms[i].className === className) {
                    arr.push(doms[i]);
                }
            }
            return arr;
        },
        //缩小搜索范围
        $class2: function (id, className) {
            //先获取这个节点的id
            var dom = FF.$id(id);
            //先获取所有元素
            var doms = dom.getElementsByTagName('*')
            var arr = []; //设置一个数组来接收classname
            //然后遍历所有元素找className
            for (var i = 0; i < doms.length; i++) {
                //如果是classname
                if (doms[i].className == className) {
                    //就往arr数组里添加classname
                    arr.push(doms[i]);
                }
            }
            return arr;
        },
        //让框架支持一个参数或者两个参数
        $class: function (id, className) {
            //获取范围;
            var dom = getid(id);
            //从这个范围中获取元素的集合
            var doms = getdoms(dom, className);
            return doms;

            function getid(id) {
                var dom;
                if (id) {
                    /*如果用户传递了id*/
                    if (FF.isString(id)) {
                        dom = FF.$id(id);
                    } else {
                        dom = id;
                    }
                } else {
                    /*如果用户没有传递id*/
                    dom = document;
                }
                return dom;
            }

            function getdoms(context, className) {
                // 第一步：先获取所有的元素
                var arr = [];
                var doms = context.getElementsByTagName('*');
                // 第二步：再从所有元素中过滤出 class名字等于className
                for (var i = 0; i < doms.length; i++) {
                    if (doms[i].className === className) {
                        arr.push(doms[i]);
                    }
                }
                return arr;
            }
        }
    })
    //层次模块
    FF.extend(FF, {
        $cengci1: function (srt) {
            var arr = srt.split(' '); //把字符串分割为字符串数组。
            //保存临时中间 的结果
            var list = [];
            //    上个管道输出的元素结合
            var context = [];
            //    最终获取的元素放在result
            var result = [];
            for (var i = 0; i < arr.length; i++) {
                var item = arr[i]; //每个字符串数组赋一个变量
                var first = item.charAt(0); //指定字符的位置//搜索每个字符串数组的位置
                var name = item.slice(1); //提取字符串数组
                result = [];
                //           如果是id
                if (first === '#') {
                    result.push(FF.$id(name)); //将带有的#名的添加到result
                    context = result; //result数组赋给context数组 清空result[]
                } else if (first === '.') { //如果是.
                    if (context.length) { //如果context数组里面有id
                        for (var j = 0; j < context.length; j++) { //就遍历循环context数组找classname
                            list = FF.$class(name, context[j]); //获取classname名赋给list数组
                            for (var k = 0; k < list.length; k++) { //遍历list数组
                                result.push(list[k]); //往result数组里加classname
                            }
                        }
                    }
                    context = result; //result数组赋给context数组 清空result[]
                } else if (context.length) { //如果是标签
                    for (var i = 0; i < context.length; i++) { //就遍历循环context数组找标签
                        list = FF.$tag(item, context[i]); //获取标签名赋给list数组
                        for (var k = 0; k < list.length; k++) { //遍历list数组
                            result.push(list[k])
                        }
                    }
                    context = result; //result数组赋给context数组 清空result[]
                } else {
                    //                如果标签放在第一位
                    list = context.length;
                    for (var i = 0; i < list.length; i++) { //直接遍历循环找标签
                        result.push(list[i])
                    }
                }
            }
            return result; //返回最终结果
        },
        /*                                         封装后的*/
        $cengci: function (str) {
            var all = str.split(" "); //把字符串分割为字符串数组
            var context = []; //保存临时中间 的结果
            var result = []; //    上个管道输出的元素结合
            var list = []; //    最终获取的元素放在result
            for (var i = 0; i < all.length; i++) {
                var item = all[i]; //每个字符串数组赋一个变量
                var first = item.charAt(0); //指定字符的位置//搜索每个字符串数组的位置
                var name = item.slice(1); //提取字符串数组
                //            如果是#
                if (first === "#") {
                    result.push(FF.$id(name)); //将id添加到result数组里
                    context = result; //然后context引用保存id  result清空
                } else if (first === ".") {
                    context = FF.cont(context, result, list, item, FF.$class); //调用
                } else {
                    context = FF.cont(context, result, list, item, FF.$tag); //调用
                }
            }
            return context;
        },
        //    封装 class 和标签的
        cont: function (context, result, list, item, callback) {
            if (context.length) { //如果context数组有id
                //就开始遍历循环找className  和  tag
                for (var i = 0; i < context.length; i++) {
                    //                                    item是标签名或者是class名
                    list = callback(item, context[i]); //获取标签和class或者标签
                    for (var j = 0; j < list.length; j++) {
                        result.push(list[j]); //      把 className  和  tag添加到最终的数组result
                    }
                }
            } else {
                //            如果是标签在第一位
                list = callback(item)
                //            直接遍历循环
                for (var j = 0; j < list.length; j++) {
                    result.push(list[j]); //往result添加
                }
            }
            return result;
        }
    })
    //设置css模块
    FF.extend(FF, {
        // 第二种  短路表达式
        $all: function (str, context) {
            //    如果是ture返回左边否则返回右边
            context = context || document;
            return context.querySelectorAll(str);
        },
        setStyle: function (dom, key, value) {
            dom.style[key] = value;
        },
        //获取css
        getStyle1: function (dom, key) {
            var str = '';
            //如果兼容标准的写法。。。。如果不兼容。。。
            if (dom.currentStyle) {
                /*如果兼容currentStyle*/
                str = dom.currentStyle[key];
            } else {
                /*使用getComputedStyle*/
                /*为什么这里只能用中括号：因为给我们的参数key是一个字符串*/
                str = window.getComputedStyle(dom, null)[key];
            }
            return str;
        },
        /*如果用户传递三个参数，设置模式，如果用户传递两个参数，我们希望获取模式*/
        css: function (context, key, value) {
            var doms = FF.isString(context) ? FF.$all(context) : context;
            if (value) {
                //三个值，设置模式
                for (var i = 0; i < doms.length; i++) {
                    setStyle(doms[i], key, value);
                }
            } else {
                //两个值,获取模式
                return getStyle(doms[0], key);
            }

            /*设置*/
            function setStyle(dom, key, value) {
                dom.style[key] = value;
            }
            /*获取*/
            function getStyle(dom, key) {
                var str = '';
                //如果兼容标准的写法。。。。如果不兼容。。。
                if (dom.currentStyle) {
                    /*如果兼容currentStyle*/
                    str = dom.currentStyle[key];
                } else {
                    /*使用getComputedStyle*/
                    /*为什么这里只能用中括号：因为给我们的参数key是一个字符串*/
                    str = window.getComputedStyle(dom, null)[key];
                }
                return str;
            }
        },
        //css的隐藏和展示
        //隐藏
        none: function (context) {
            FF.css(context, 'display', 'none')
        },
        //展示
        show: function (context) {
            FF.css(context, 'display', 'block')
        },
        // html()
        html: function (context, value) {
            var doms = FF.$all(context)
            // 设置模式
            if (value) {
                for (var i = 0; i < doms.length; i++) {
                    doms[i].innerHTML = value;
                }
            } else {
                //        获取模式
                return doms[0].innerHTML;
            }
        },
        // 自定义属性
        attr: function (context, key, value) {
            var doms = FF.$all(context);
            if (value) { //设置模式
                for (var i = 0; i < doms.length; i++) {
                    setDOM(doms[i], key, value);
                }
            } else {
                //            获取模式
                return getDOM(doms[0], key);
            }

            //        设置模式
            function setDOM(dom, key, value) {
                dom.setAttribute(key, value);
            }

            //获取模式
            function getDOM(dom, key, value) {
                dom.setAttribute(key, value);
            }
        },
        removeAttr: function () {
            //arguments是伪数组 根本就无法调用数组对象中的方法
            /*如何将伪数组转成真数组*/
            var args = Array.prototype.slice.call(arguments);
            var str = args[0];
            /*属性集合*/
            var names = args.slice(1);
            var doms = FF.$all(str);
            for (var i = 0; i < doms.length; i++) {
                /*去除某个元素的属性集合*/
                removeDOMAttributes(doms[i]);

                /*去除单个元素的所有属性*/
                function removeDOMAttributes(dom) {
                    for (var j = 0; j < names.length; j++) {
                        dom.removeAttribute(names[j]);
                    }
                }
            }
            },
            addClass: function (context, className) {
                var doms = FF.$all(context);
                for (var i = 0; i < doms.length; i++) {
                    //给一个元素添加 多个属性
                    addOne(doms[i]);
                }

                function addOne(dom) {
                    dom.className = dom.className + " " + className;
                    //            dom.className = dom.className.join(' ').trim();
                }
            },
            removeClass: function (context, className) {
                var doms = FF.$all(context); //获取这个节点的集合
                for (var i = 0; i < doms.length; i++) {
                    //移除元素的className
                    removeOne(doms[i])
                }

                function removeOne(dom) {
                    dom.className = dom.className.replace(className, ''); //空格替换成属性
                    var arry = dom.className.split('  '); //分割字符串数组
                    dom.className = arry.join(' ').trim(); //拼接字符串 清除左右空格
                }
            },
            val: function (context, value) {
                var doms = FF.$all(context);
                if (value) { //设置模式
                    for (var i = 0; i < doms.length; i++) {
                        doms[i].value = value;
                    }
                } else {
                    //            获取模式
                    return doms[0].value
                }
            }
        })
    // 缓速动画模块
    FF.extend(FF, {
        animate: function (obj, json, fn) {
            clearInterval(obj.timer);
            obj.timer = setInterval(function () {
                var flag = true;
                for (var k in json) {
                    var target = json[k];
                    var leader = parseInt(FF.getStyle(obj, k));
                    var step = (target - leader) / 10;
                    step = step > 0 ? Math.ceil(step) : Math.floor(step);
                    leader = leader + step;
                    obj.style[k] = leader + "px";
                    /*if (leader == target) {
                     clearInterval(obj.timer);
                     }*/
                    //width: 2, height: 200, top: 50, left: 20
                    if (leader != target) {
                        flag = false;
                    }
                }
                if (flag) {
                    clearInterval(obj.timer);
                    if (fn) {
                        fn();
                    }
                }
            }, 30)
        },
        getStyle: function (obj, attr) {
            if (obj.currentStyle) {
                return obj.currentStyle[attr];
            } else {
                return window.getComputedStyle(obj, null)[attr];
            }
        }
    })
    // 变速运动模块
    FF.extend(FF, {
        // animate(ani,5000,500,10,'width');
        // 第一个参数是dom元素
        // 第二个参数持续的时间
        // 第三个参数移动的距离
        // 第四个参数移动的方向
        animate: function (dom, duration, juli, sj, style) {
            var start = 0;
            var now1 = +new Date();
            var timer;
            var tween;
            timer = setInterval(move, sj);

            function getTween(easy, now1, now2, duration) {
                var eases = {
                    //线性匀速
                    linear: function (t, b, c, d) {
                        return (c - b) * (t / d);
                    },
                    //弹性运动
                    easeOutBounce: function (t, b, c, d) {
                        if ((t /= d) < (1 / 2.75)) {
                            return c * (7.5625 * t * t) + b;
                        } else if (t < (2 / 2.75)) {
                            return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
                        } else if (t < (2.5 / 2.75)) {
                            return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
                        } else {
                            return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
                        }
                    },
                    //其他
                    swing: function (t, b, c, d) {
                        return this.easeOutQuad(t, b, c, d);
                    },
                    easeInQuad: function (t, b, c, d) {
                        return c * (t /= d) * t + b;
                    },
                    easeOutQuad: function (t, b, c, d) {
                        return -c * (t /= d) * (t - 2) + b;
                    },
                    easeInOutQuad: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return c / 2 * t * t + b;
                        return -c / 2 * ((--t) * (t - 2) - 1) + b;
                    },
                    easeInCubic: function (t, b, c, d) {
                        return c * (t /= d) * t * t + b;
                    },
                    easeOutCubic: function (t, b, c, d) {
                        return c * ((t = t / d - 1) * t * t + 1) + b;
                    },
                    easeInOutCubic: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return c / 2 * t * t * t + b;
                        return c / 2 * ((t -= 2) * t * t + 2) + b;
                    },
                    easeInQuart: function (t, b, c, d) {
                        return c * (t /= d) * t * t * t + b;
                    },
                    easeOutQuart: function (t, b, c, d) {
                        return -c * ((t = t / d - 1) * t * t * t - 1) + b;
                    },
                    easeInOutQuart: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
                        return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
                    },
                    easeInQuint: function (t, b, c, d) {
                        return c * (t /= d) * t * t * t * t + b;
                    },
                    easeOutQuint: function (t, b, c, d) {
                        return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
                    },
                    easeInOutQuint: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
                        return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
                    },
                    easeInSine: function (t, b, c, d) {
                        return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
                    },
                    easeOutSine: function (t, b, c, d) {
                        return c * Math.sin(t / d * (Math.PI / 2)) + b;
                    },
                    easeInOutSine: function (t, b, c, d) {
                        return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
                    },
                    easeInExpo: function (t, b, c, d) {
                        return (t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
                    },
                    easeOutExpo: function (t, b, c, d) {
                        return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
                    },
                    easeInOutExpo: function (t, b, c, d) {
                        if (t == 0) return b;
                        if (t == d) return b + c;
                        if ((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
                        return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
                    },
                    easeInCirc: function (t, b, c, d) {
                        return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
                    },
                    easeOutCirc: function (t, b, c, d) {
                        return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
                    },
                    easeInOutCirc: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
                        return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
                    },
                    easeInElastic: function (t, b, c, d) {
                        var s = 1.70158;
                        var p = 0;
                        var a = c;
                        if (t == 0) return b;
                        if ((t /= d) == 1) return b + c;
                        if (!p) p = d * .3;
                        if (a < Math.abs(c)) {
                            a = c;
                            var s = p / 4;
                        } else var s = p / (2 * Math.PI) * Math.asin(c / a);
                        return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
                    },
                    easeOutElastic: function (t, b, c, d) {
                        var s = 1.70158;
                        var p = 0;
                        var a = c;
                        if (t == 0) return b;
                        if ((t /= d) == 1) return b + c;
                        if (!p) p = d * .3;
                        if (a < Math.abs(c)) {
                            a = c;
                            var s = p / 4;
                        } else var s = p / (2 * Math.PI) * Math.asin(c / a);
                        return a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b;
                    },
                    easeInOutElastic: function (t, b, c, d) {
                        var s = 1.70158;
                        var p = 0;
                        var a = c;
                        if (t == 0) return b;
                        if ((t /= d / 2) == 2) return b + c;
                        if (!p) p = d * (.3 * 1.5);
                        if (a < Math.abs(c)) {
                            a = c;
                            var s = p / 4;
                        } else var s = p / (2 * Math.PI) * Math.asin(c / a);
                        if (t < 1) return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
                        return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
                    },
                    easeInBack: function (t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        return c * (t /= d) * t * ((s + 1) * t - s) + b;
                    },
                    easeOutBack: function (t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
                    },
                    easeInOutBack: function (t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        if ((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
                        return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
                    },
                    easeInBounce: function (t, b, c, d) {
                        return c - this.easeOutBounce(d - t, 0, c, d) + b;
                    },
                    easeInOutBounce: function (t, b, c, d) {
                        if (t < d / 2) return this.easeInBounce(t * 2, 0, c, d) * .5 + b;
                        return this.easeOutBounce(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
                    }
                }
                var pass = now2 - now1;
                var tween = eases[easy](pass, 0, 1, duration);
                return tween;
            }

            function stop() {
                clearInterval(timer);
            }

            function oneStyle(dom, style, start, juli, tween) {

                dom.style[style] = start + juli * tween + "px";
            }

            function move() {
                var now2 = +new Date();
                /*        var pass=now2-now1;
                 tween=pass/duration;
                 console.log(tween);*/
                tween = getTween('easeOutBounce', now1, now2, duration);
                if (tween > 1) {
                    stop();
                } else {
                    oneStyle(dom, style, start, juli, tween);
                }
            }
        }
    });
    //  封装ajax 封装jsonp 截取URL参数模块
    FF.extend(FF, {
        //  封装ajax
        ajax: function (method, url, data, success) {
            var xhr = null;
            try {

                xhr = new XMLHttpRequest()
            } catch (e) {
                xhr = new ActiveXObject("Microcoft.XMLHTTP"); //兼容6以下
            }
            if (method == "get" && data) {
                url += '?' + data;
            }
            xhr.open(method, url, true)
            if (method == "get") {
                xhr.send()
            } else {
                xhr.setRequestHeader("content-type", "application/x-www-form-unLencoded")
                xhr.send(data)
            }
            xhr.onreadystatechange = function () {
                // 响应完成
                if (xhr.readyState == 4) {
                    // 响应成功
                    if (xhr.status == 200) {
                        success && success(xhr.responseText)
                    } else {
                        alert("error:" + xhr.status)
                    }
                }
            }
        },
        // 封装jsonp
        jsonp: function (url, arg, callback) {
            // 1拼接字符串  参数  如  id=1&name="小名"
            var queryString = "";
            for (var key in arg) {
                queryString += key + "=" + arg[key] + "&"
            }
            url += "?" + queryString;
            // 加上callback
            // 响应回来的有点（.）所以从第二位开始  截取
            var cbName = 'jsonp_' + Math.random().toString().substr(2);
            //window.jsonp_2182192=callback;
            window[cbName] = function (data) {
                callback(data);
                document.body.removeChild(scriptElement);
            };
            url = url + 'callback=' + cbName;
            // 2创建script标签  并且把拼接后的URL放到src上
            var scriptElement = document.createElement('script');
            scriptElement.src = url;
            // 3.把script标签加入到页面里
            document.body.appendChild(scriptElement);
        },
        // 截取URL参数
        parseQueryString: function (url) {
            var str = url.split("?")[1].split("&");
            var items = str;
            var result = {};
            var arr = '';
            // 为数组转换真数组
            // var qwe= Array.prototype.slice.call(items);
            // console.log(qwe)
            for (var i = 0; i < items.length; i++) {
                var arr = items[i].split("=");
                result[arr[0]] = arr[1];
            }
            return result;
        }
        // 例如
        //  var url="http://www.xiaoyu.com/abc.com?a=0&bb=1&ccc=2";
        //  var obj=parseQueryString(url);
        // console.log(obj)
    });
    // 计时器模块
    FF.extend(FF, {
        start: function () {
            //使用setInterval函数进行定时
            window.setInterval(function () {
                //得到当前的时间对象
                var date = new Date();
                var str = ''; //定义拼接的字符变量
                //得到小时数
                str += date.getHours();
                str += ':'; //拼接冒号
                //得到分钟数
                str += date.getMinutes();
                str += ':'; //拼接冒号
                //得到秒数
                str += date.getSeconds();
                //把结果显示出来
                document.getElementById('the_sec').innerHTML = str;
            }, 1000); //间隔为1秒
        },
    });
    // 闭包封装tab
    FF.extend(FF, {
        tab: function (id) {
            // 获取元素   只获取  这个id 下面的span 和 li
            var eleId = document.getElementById(id);  // 获取id元素
            var spans = eleId.getElementsByTagName("span");  //  span 4个小span
            var lis = eleId.getElementsByTagName("li");  //  4个小li
            for (var i = 0; i < spans.length; i++) {  // 遍历 4个 span
                //spans[i].index = i;  // 每个span得到索引号
                spans[i].onmouseover = function (num) {
                    return function () {
                        //这里面的num就是循环遍历时的i
                        //干掉所有人
                        for (var j = 0; j < spans.length; j++) {
                            spans[j].className = "";
                            lis[j].className = "";
                        }
                        //留下我自己
                        spans[num].className = "current";
                        lis[num].className = "current";
                    }
                }(i);//i代表tab栏的索引
            }
        },
        // 拖拽
        tz: function (d_box, d_boxh) {
            d_boxh.onmousedown = function (event) {
                var event = event || window.event;//事件IE6/7/8只支持window.event
                var pageY = event.pageY || event.clientY + document.documentElement.scrollTop;
                var pageX = event.pageX || event.clientX + document.documentElement.scrollLeft;
                var spaceX = pageX - d_box.offsetLeft;
                var spaceY = pageY - d_box.offsetTop;
                document.onmousemove = function (event) {
                    var event = event || window.event;
                    var pageY = event.pageY || event.clientY + document.documentElement.scrollTop;
                    var pageX = event.pageX || event.clientX + document.documentElement.scrollLeft;
                    d_box.style.left = pageX - spaceX + "px";
                    d_box.style.top = pageY - spaceY + "px";
                    //IE9以下支持：document.selection
                    //IE9、Firefox、Safari、Chrome和Opera支持：window.getSelection()
                    //js 中的selection对象使用笔记+光标定位
                    // document.selection.createRange();  // 创建文本区域对象
                    window.getSelection ? window.getSelection().removeAllRanges() : document.selection.empty();
                }
            }
            document.onmouseup = function () {
                document.onmousemove = null;
            }
        }
        //获取元素
        // var d_boxs = document.getElementById("d_box");
        // var drops = document.getElementById("drop");
        //   FF.tz(d_boxs,drops)
    });
    /*双对象法则*/
    /*双管齐下*/

    /* 思路：如果str是一个字符串类型 ---表示根据str获取dom集合
     如果str是一个函数  ---调用window.onload = str*/
    function myItcast(str, context) {
        /* if (typeof str == 'function'){
         window.onload = str;
         }else{
         return $$.$all(str,context);
         }*/
        if (FF.isString(str)) {
            return FF.$all(str, context);
        } else {
            window.onload = str;
        }
    };
    //给window  定义了一个属性
    window.FF = $ = FF; //设置window在外面可以调用不设置调用不了
})(window);
